/**
 * 坐标转换和计算工具函数
 */

/**
 * 将相对坐标转换为绝对坐标
 * @param {Object} relativeCoord - 相对坐标对象 {x, y, width, height}
 * @param {number} displayWidth - 图片显示宽度
 * @param {number} displayHeight - 图片显示高度
 * @param {number} actualWidth - 图片实际宽度 (可选)
 * @param {number} actualHeight - 图片实际高度 (可选)
 * @returns {Object} 绝对坐标对象
 */
export function relativeToAbsolute(
  relativeCoord,
  displayWidth,
  displayHeight,
  actualWidth,
  actualHeight
) {
  const scaleX = displayWidth / actualWidth;
  const scaleY = displayHeight / actualHeight;

  return {
    x: relativeCoord.x * scaleX,
    y: relativeCoord.y * scaleY,
    width: relativeCoord.width * scaleX,
    height: relativeCoord.height * scaleY,
  };
}

/**
 * 将绝对坐标转换为相对坐标
 * @param {Object} absoluteCoord - 绝对坐标对象 {x, y, width, height}
 * @param {number} displayWidth - 图片显示宽度
 * @param {number} displayHeight - 图片显示高度
 * @param {number} actualWidth - 图片实际宽度 (可选)
 * @param {number} actualHeight - 图片实际高度 (可选)
 * @returns {Object} 相对坐标对象
 */
export function absoluteToRelative(
  absoluteCoord,
  displayWidth,
  displayHeight,
  actualWidth,
  actualHeight
) {
  const scaleX = displayWidth / actualWidth;
  const scaleY = displayHeight / actualHeight;

  return {
    x: absoluteCoord.x / scaleX,
    y: absoluteCoord.y / scaleY,
    width: absoluteCoord.width / scaleX,
    height: absoluteCoord.height / scaleY,
  };
}

/**
 * 限制坐标在图片范围内
 * @param {Object} coord - 坐标对象 {x, y, width, height}
 * @param {number} imageWidth - 图片宽度
 * @param {number} imageHeight - 图片高度
 * @param {boolean} isRelative - 是否为相对坐标 (0-1范围)
 * @returns {Object} 限制后的坐标对象
 */
export function constrainToBounds(
  coord,
  imageWidth,
  imageHeight,
  isRelative = false
) {
  let { x, y, width, height } = coord;

  if (isRelative) {
    // 处理相对坐标 (0-1范围)
    // 限制位置
    x = Math.max(0, Math.min(x, 1 - width));
    y = Math.max(0, Math.min(y, 1 - height));

    // 限制尺寸
    width = Math.min(width, 1 - x);
    height = Math.min(height, 1 - y);
  } else {
    // 处理绝对坐标 (像素值)
    // 限制位置
    x = Math.max(0, Math.min(x, imageWidth - width));
    y = Math.max(0, Math.min(y, imageHeight - height));

    // 限制尺寸
    width = Math.min(width, imageWidth - x);
    height = Math.min(height, imageHeight - y);
  }

  return { x, y, width, height };
}

/**
 * 根据旋转角度转换坐标
 * @param {Object} coord - 原始坐标
 * @param {number} rotation - 旋转角度 (0, 90, 180, 270)
 * @param {number} imageWidth - 图片宽度
 * @param {number} imageHeight - 图片高度
 * @param {boolean} isRelative - 是否为相对坐标 (0-1范围)
 * @returns {Object} 转换后的坐标
 */
export function rotateCoordinate(
  coord,
  rotation,
  imageWidth,
  imageHeight,
  isRelative = false
) {
  const { x, y, width, height } = coord;

  // 对于相对坐标，需要特殊处理
  if (isRelative) {
    switch (rotation) {
      case 90:
        return {
          x: y,
          y: 1 - x - width,
          width: height,
          height: width,
        };
      case 180:
        return {
          x: 1 - x - width,
          y: 1 - y - height,
          width: width,
          height: height,
        };
      case 270:
        return {
          x: 1 - y - height,
          y: x,
          width: height,
          height: width,
        };
      default:
        return { x, y, width, height };
    }
  }

  // 绝对坐标处理
  switch (rotation) {
    case 90:
      return {
        x: y,
        y: imageWidth - x - width,
        width: height,
        height: width,
      };
    case 180:
      return {
        x: imageWidth - x - width,
        y: imageHeight - y - height,
        width: width,
        height: height,
      };
    case 270:
      return {
        x: imageHeight - y - height,
        y: x,
        width: height,
        height: width,
      };
    default:
      return { x, y, width, height };
  }
}

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export function generateId() {
  return "box_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
}

/**
 * 检查点是否在矩形内
 * @param {number} pointX - 点的X坐标
 * @param {number} pointY - 点的Y坐标
 * @param {Object} rect - 矩形对象 {x, y, width, height}
 * @param {boolean} isRelative - 是否为相对坐标 (0-1范围)
 * @returns {boolean} 是否在矩形内
 */
export function isPointInRect(pointX, pointY, rect, isRelative = false) {
  // 无论是相对坐标还是绝对坐标，判断逻辑相同
  // 只是在调用时需确保点和矩形使用相同的坐标系统
  return (
    pointX >= rect.x &&
    pointX <= rect.x + rect.width &&
    pointY >= rect.y &&
    pointY <= rect.y + rect.height
  );
}

/**
 * 计算两个矩形的交集
 * @param {Object} rect1 - 第一个矩形
 * @param {Object} rect2 - 第二个矩形
 * @param {boolean} isRelative - 是否为相对坐标 (0-1范围)
 * @returns {Object|null} 交集矩形或null
 */
export function getIntersection(rect1, rect2, isRelative = false) {
  // 无论是相对坐标还是绝对坐标，计算逻辑相同
  // 只需确保两个矩形使用相同的坐标系统
  const left = Math.max(rect1.x, rect2.x);
  const top = Math.max(rect1.y, rect2.y);
  const right = Math.min(rect1.x + rect1.width, rect2.x + rect2.width);
  const bottom = Math.min(rect1.y + rect1.height, rect2.y + rect2.height);

  if (left < right && top < bottom) {
    return {
      x: left,
      y: top,
      width: right - left,
      height: bottom - top,
    };
  }

  return null;
}

/**
 * 验证坐标数据格式
 * @param {Array} coordinates - 坐标数组
 * @param {boolean} isRelative - 是否为相对坐标 (0-1范围) 而非像素坐标
 * @returns {boolean} 是否有效
 */
export function validateCoordinates(coordinates, isRelative = false) {
  if (!Array.isArray(coordinates)) return false;

  return coordinates.every((coord) => {
    // 基本类型检查
    const basicCheck =
      coord &&
      typeof coord.id === "string" &&
      typeof coord.x === "number" &&
      typeof coord.y === "number" &&
      typeof coord.width === "number" &&
      typeof coord.height === "number" &&
      coord.width > 0 &&
      coord.height > 0;

    if (!basicCheck) return false;

    // 如果是相对坐标，检查范围是否在0-1之间
    if (isRelative) {
      return (
        coord.x >= 0 &&
        coord.x <= 1 &&
        coord.y >= 0 &&
        coord.y <= 1 &&
        coord.width > 0 &&
        coord.width <= 1 &&
        coord.height > 0 &&
        coord.height <= 1
      );
    }

    // 对于绝对像素坐标，只要是有效的正数值即可
    return coord.x >= 0 && coord.y >= 0;
  });
}
